#include <bits/stdc++.h>
const int LEN = 362880;	//转态共9! = 362880种
using namespace std;
/*
在一个 3×3的棋盘上放置编号为1～8的8个方块,每个占一格,另外还有一个空格。
与空格相邻的数字方块可以移动到空格里。

指定初始棋局和目标棋局(如图4.2所示）,计算出最少的移动步数；
输入：
1 2 3 0 8 4 7 6 5
1 0 3 8 2 4 7 6 5
输出：
2
*/
struct node{
    int state[9];
    int dis;
};
int dir[4][2] = {
    {-1, 0}, {0, -1}, {1, 0}, {0,1}
};

//与每个状态对应的记录，Cantor()函数对它置数，并判重
int visited[LEN] = {0};	
int start[9];	//开始状态
int goal[9];	//目标状态
//cantor() 用到的常数
long factory[] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};//factory[i] = i!

//用康托展开判重
bool cantor(int str[], int n){
    long result = 0;
    for(int i = 0; i < n; i++){
        int counted = 0;    //当前未出现的元素比当前数小的个数
        for(int j = i + 1; j < n; j++){
            if(str[i] > str[j])	
                ++counted;
        }
        result += counted * factory[n - i - 1];
    }
    if(!visited[result]){	//没有访问过
        visited[result] = 1;
        return 1;
    }else{
        return 0;
    }
}

int bfs(){
    node head;
    //复制起点的状态
    memcpy(head.state, start, sizeof(head.state));
    head.dis = 0;
    //队列中的内容是记录状态
    queue<node> q;
    //用康托展开判重，目的是对起点的visited[]赋初值
    cantor(head.state, 9);
    //第一个进队列的是起点状态
    q.push(head);
    while(!q.empty()){
        head = q.front();
        q.pop();
        //与目标转态对比
        if(memcmp(head.state, goal, sizeof(goal)) == 0){
            //到达目标转态，返回距离
            return head.dis;
        }
        int z;
        //找这个状态中元素0的位置
        for(z = 0; z < 9; z++){
            if(head.state[z] == 0){
                break;
            }
        }
        //转为二维
        int x = z % 3;
        int y = z / 3;
        for(int i = 0; i < 4; i++){
            int newX = x + dir[i][0];
            int newY = y + dir[i][1];
            int nZ = newX + 3 * newY;
            if(newX >= 0 && newX < 3 && newY >= 0 && newY < 3){
                node newNode;
                //复制这新的状态
                memcpy(&newNode, &head, sizeof(struct node));
                //把0移动到新的位置
                swap(newNode.state[z], newNode.state[nZ]);
                newNode.dis++;
                
                //用康托展开判重
                if(cantor(newNode.state, 9)){
                    //把新的状态放进队列
                    q.push(newNode);
                }
            }
        }
    }
    return -1;	//没找到
}
// int f(int n){
//     if(n == 0 || n == 1) return n;
//     return n * f(n - 1);
// }

int main(){
    for(int i = 0; i < 9; i++) cin>>start[i];
    for(int i = 0; i < 9; i++) cin>>goal[i];
    int num = bfs();
    if(num != -1) cout<<num<<endl;
    else cout<<"Impossible"<<endl;

    return 0;
}